
// pages/edit/index.js
const { todoManager, tagManager, reminderManager } = require('../../utils/cloud')
const { formatDateTime, validateDateTime } = require('../../utils/dateHelper')
const { toast, dialog, nav, errorHandler } = require('../../utils/uiHelper')

const app = getApp()

Page({
  data: {
    // 表单数据
    formData: {
      title: '',
      content: '',
      reminderDate: '', // 提醒日期
      reminderTime: '', // 提醒时间（小时:分钟）
      tags: []
    },
    // 是否为编辑模式
    isEdit: false,
    // 当前项目ID（编辑模式下使用）
    todoId: '',
    // 可选标签列表
    availableTags: [],
    // 日期选择器的最小日期（当前日期）
    minDate: new Date().toISOString().split('T')[0],
    // 当前时间（用于时间选择器默认值）
    currentTime: new Date().toTimeString().substr(0, 5),
    // 加载状态
    isLoading: false,
    // 提交状态
    isSubmitting: false
  },

  onLoad: async function(options) {
    // 检查登录状态
    if (!app.checkLogin()) {
      nav.back()
      return
    }

    // 设置当前日期为默认值
    const today = new Date().toISOString().split('T')[0]
    const currentTime = new Date().toTimeString().substr(0, 5)
    
    this.setData({
      'formData.reminderDate': today,
      'formData.reminderTime': currentTime
    })

    // 如果传入了 id 参数，说明是编辑模式
    if (options.id) {
      this.setData({
        isEdit: true,
        todoId: options.id
      })
      await this.loadTodoData(options.id)
    }
    
    // 加载可用标签
    await this.loadTags()
  },

  // 加载待办事项数据（编辑模式）
  async loadTodoData(id) {
    try {
      this.setData({ isLoading: true })
      toast.loading('加载中...')

      // 模拟从云数据库加载待办事项数据
      // 实际应用中应该调用云函数获取数据
      const result = await wx.cloud.callFunction({
        name: 'todoManager',
        data: {
          type: 'getTodoById',
          data: { _id: id }
        }
      })

      if (result.result.code === 0) {
        const todo = result.result.data
        
        // 将reminderTime拆分为reminderDate和reminderTime
        const date = new Date(todo.reminderTime)
        const reminderDate = formatDateTime.date(date)
        const reminderTime = formatDateTime.time(date)

        this.setData({
          formData: {
            title: todo.title,
            content: todo.content || '',
            reminderDate,
            reminderTime,
            tags: todo.tags || []
          }
        })
      } else {
        throw new Error(result.result.msg || '加载数据失败')
      }
    } catch (err) {
      errorHandler.handle(err, '加载数据失败')
      nav.back()
    } finally {
      this.setData({ isLoading: false })
      toast.hideLoading()
    }
  },

  // 加载标签列表
  async loadTags() {
    try {
      this.setData({ isLoading: true })
      
      const result = await tagManager.listTags()
      
      if (result.code === 0) {
        // 如果没有标签，初始化默认标签
        if (result.data.length === 0) {
          const initResult = await tagManager.initDefaultTags()
          if (initResult.code === 0) {
            this.setData({ availableTags: initResult.data })
          }
        } else {
          this.setData({ availableTags: result.data })
        }
      } else {
        throw new Error(result.msg)
      }
    } catch (err) {
      errorHandler.handle(err, '加载标签失败')
    } finally {
      this.setData({ isLoading: false })
    }
  },

  // 标题输入处理
  onTitleInput: function(e) {
    this.setData({
      'formData.title': e.detail.value
    })
  },

  // 内容输入处理
  onContentInput: function(e) {
    this.setData({
      'formData.content': e.detail.value
    })
  },

  // 日期选择处理
  onDateChange: function(e) {
    this.setData({
      'formData.reminderDate': e.detail.value
    })
  },

  // 时间选择处理
  onTimeChange: function(e) {
    this.setData({
      'formData.reminderTime': e.detail.value
    })
  },

  // 标签选择处理
  onTagSelect: function(e) {
    const tag = e.currentTarget.dataset.tag
    const index = this.data.formData.tags.indexOf(tag)
    
    if (index === -1 && this.data.formData.tags.length < 5) {
      // 添加标签
      this.setData({
        'formData.tags': [...this.data.formData.tags, tag]
      })
    } else if (index !== -1) {
      // 移除标签
      const newTags = [...this.data.formData.tags]
      newTags.splice(index, 1)
      this.setData({
        'formData.tags': newTags
      })
    }
  },

  // 格式化提醒时间
  formatReminderDateTime: function(date, time) {
    // 创建一个基于本地时区的日期对象
    const [year, month, day] = date.split('-').map(Number);
    const [hours, minutes] = time.split(':').map(Number);
    
    // 使用本地时区创建日期对象
    const localDate = new Date(year, month - 1, day, hours, minutes, 0);
    
    // 格式化为ISO字符串并保留本地时间
    const isoString = new Date(
      localDate.getFullYear(),
      localDate.getMonth(),
      localDate.getDate(),
      localDate.getHours(),
      localDate.getMinutes(),
      0
    ).toISOString();

    console.log('原始日期时间:', date, time);
    console.log('格式化后的时间:', isoString);
    console.log('本地时间对象:', localDate);
    
    return isoString;
  },

  // 表单验证
  validateForm: function() {
    const { title, reminderDate, reminderTime } = this.data.formData
    
    if (!title.trim()) {
      toast.info('请输入标题')
      return false
    }

    if (!reminderDate) {
      toast.info('请选择提醒日期')
      return false
    }

    if (!reminderTime) {
      toast.info('请选择提醒时间')
      return false
    }

    // 组合日期和时间
    const reminderDateTime = this.formatReminderDateTime(reminderDate, reminderTime)
    
    // 验证提醒时间是否早于当前时间
    if (new Date(reminderDateTime) < new Date()) {
      toast.info('提醒时间不能早于当前时间')
      return false
    }

    return true
  },

  // 请求提醒订阅权限
  async requestReminderSubscription() {
    try {
      const result = await reminderManager.requestSubscribe()
      return result
    } catch (err) {
      console.error('请求订阅失败：', err)
      return false
    }
  },

  // 表单提交
  async onSubmit() {
    try {
      // 表单验证
      if (!this.validateForm()) return
      
      this.setData({ isSubmitting: true })
      toast.loading(this.data.isEdit ? '保存中...' : '创建中...')

      // 请求提醒订阅权限
      await this.requestReminderSubscription()

      const { title, content, reminderDate, reminderTime, tags } = this.data.formData
      
      // 组合日期和时间
      const reminderDateTime = this.formatReminderDateTime(reminderDate, reminderTime)
      
      let result
      if (this.data.isEdit) {
        // 更新已有待办事项 - 只更新需要修改的字段
        result = await todoManager.updateTodo({
          _id: this.data.todoId,
          title: title.trim(),
          content: content.trim(),
          reminderTime: reminderDateTime,
          tags
          // 注意：不更新status字段，保留原状态
        })
      } else {
        // 创建新的待办事项
        const todoData = {
          title: title.trim(),
          content: content.trim(),
          reminderTime: reminderDateTime,
          tags,
          status: false
        }
        result = await todoManager.createTodo(todoData)
      }

      if (result.code === 0) {
        toast.success(this.data.isEdit ? '保存成功' : '创建成功')
        // 提交成功后返回上一页
        nav.back()
      } else {
        throw new Error(result.msg)
      }
    } catch (err) {
      errorHandler.handle(err, this.data.isEdit ? '保存失败' : '创建失败')
    } finally {
      this.setData({ isSubmitting: false })
      toast.hideLoading()
    }
  }
})